home *** CD-ROM | disk | FTP | other *** search
/ Gekkan Dennou Club 147 / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan).7z / Gekkan Dennou Club - 2000.8 Vol. 147 (Japan) (Track 1).bin / tools / zmc3v078 / zmc3v078.lzh / SRCSV078.LZH / ARCC.C < prev    next >
C/C++ Source or Header  |  2000-01-09  |  14KB  |  550 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "etc.h"
  5. #include "makezmd3.h"
  6. #include "parsesub.h"
  7. #include "velo.h"
  8. #include "68lib.h"
  9.  
  10.  
  11. #include "structs.h"
  12. #include "structs2.h"
  13. UBYTE *makeARCCCommand(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  14.                         TRKINF *trkinf);
  15. UBYTE *makeARCClevel(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  16.                         DWORD no, TRKINF *trkinf);
  17. UBYTE *makeARCClevel0(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  18.                         TRKINF *trkinf, int no, int mode);
  19. UBYTE *makeARCCdeepen(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no,
  20.                         TRKINF *trkinf);
  21. UBYTE *makeARCCcontrol(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no);
  22. UBYTE *makeARCCorigin(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no);
  23. UBYTE *makeARCCreset(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no);
  24. UBYTE *makeARCCswitch(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no);
  25. UBYTE *makeARCCwaveform(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no);
  26. UBYTE *makeARCCsync(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no);
  27. UBYTE *makeARCCmode(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no);
  28. UBYTE *makeARCCphase(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no);
  29. UBYTE *makeARCCoffset(UBYTE *zms,TRKINF *trkinf, const BYTE target[],DWORD no);
  30.  
  31.  
  32. extern DWORD line;
  33. extern char *linebuf;
  34. extern LINEDATA *ld;
  35.  
  36.  
  37. UBYTE *makeARCCCommand(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  38.                         TRKINF *trkinf)
  39. {
  40.     DWORD no, tmpDWORD;
  41.     int i, trk,err;
  42.     DWORD line_ = line;
  43.     char *linebuf_ = linebuf;
  44.     const char *comtbl[] = {
  45.         "level","depth","deepen","control","origin","reset",
  46.         "speed","delay","waveform","switch","sync","mode","phase",
  47.         "offset",
  48.         NULL
  49.     };
  50.  
  51.     zms = getnum2(zms, &no, &err);
  52.     if (err) {
  53.         zmserror("[ARCC] command must contain the ARCC target number.",line_,linebuf_,zms,0,1);
  54.     } else if (no < 1 && 4< no) {
  55.         zmserror("ARCC target number is out of range.",line_,linebuf_,zms,0,1);
  56.     }
  57.     no--;
  58.     zms = skipSpc(zms);
  59.     if (*zms++ != '.') {
  60.         zmserror("[ARCC] format error.",line_,linebuf_,zms,0,1);
  61.     }
  62.  
  63.     for (i = 0;;i++) {
  64.         if (!comtbl[i]) {
  65.             i = -1;
  66.             break;
  67.         } else if (!stricmp2(zms,comtbl[i])) {
  68.             zms += strlen(comtbl[i]);
  69.             break;
  70.         }
  71.     }
  72.  
  73.     switch (i) {
  74.         case 0:            /* [ARCCn.level */
  75.         case 1:            /* [ARCCn.depth */
  76.             zms = makeARCClevel(zms,trkdata,target,no,trkinf);
  77.             break;
  78.         case 2:            /* deepen */
  79.             zms = makeARCCdeepen(zms,trkdata,target,no,trkinf);
  80.             break;
  81.         case 3:            /* control */
  82.             zms = makeARCCcontrol(zms,trkdata,target,no);
  83.             break;
  84.         case 4:            /* origin */
  85.             zms = makeARCCorigin(zms,trkdata,target,no);
  86.             break;
  87.         case 5:            /* reset */
  88.             zms = makeARCCreset(zms,trkdata,target,no);
  89.             break;
  90.         case 6:            /* speed */
  91.             {
  92.                 const BYTE parabytes[8] = {2,2,2,2,2,2,2,2};
  93.                 zms = makeZmdManyParas2(zms,trkdata,target,line,linebuf,
  94.                             0xE6, 8, parabytes, 1, no, 0, 2, 1,
  95.                             "[ARCCn.speed]: too many parameters.",
  96.                             "[ARCCn.speed] can't use relatinal parameters.",
  97.                             "");
  98.             }
  99.             break;
  100.         case 7:            /* delay */
  101.             {
  102.                 const BYTE parabytes[9] = {2,2,2,2,2,2,2,2,2};
  103.                 zms = makeZmdManyParas2(zms,trkdata,target,line,linebuf,
  104.                             0xE7, 9, parabytes, 1, no, 0, 1, 0,
  105.                             "[ARCCn.delay]: too many parameters.",
  106.                             "[ARCCn.delay] can't use relatinal parameters.",
  107.                             "");
  108.             }
  109.             break;
  110.         case 8:            /* waveform */
  111.             zms = makeARCCwaveform(zms,trkdata,target,no);
  112.             break;
  113.         case 9:            /* switch */
  114.             zms = makeARCCswitch(zms,trkdata,target,no);
  115.             break;
  116.         case 10:        /* sync */
  117.             zms = makeARCCsync(zms,trkdata,target,no);
  118.             break;
  119.         case 11:        /* mode */
  120.             zms = makeARCCmode(zms,trkdata,target,no);
  121.             break;
  122.         case 12:        /* phase */
  123.             zms = makeARCCphase(zms,trkdata,target,no);
  124.             break;
  125.         case 13:        /* offset */
  126.             zms = makeARCCoffset(zms,trkinf,target,no);
  127.             break;
  128.         default:        /* ERROR */
  129.             break;
  130.     }
  131.  
  132.     zms = skipSpc(zms);
  133.     if (*zms++ != ']') {
  134.         zmserror("[ARCC] is not closed.",line_,linebuf_,zms,0,1);
  135.     }
  136.     return zms;
  137. }
  138.  
  139.  
  140. UBYTE *makeARCClevel(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no,
  141.                         TRKINF *trkinf)
  142. {
  143.     const char *p[] = {"1/8", "off", "optional", "on", NULL};
  144.     DWORD mode;
  145.     int err;
  146.     UBYTE *zms_;
  147.     int i, flag = 1;
  148.  
  149.     zms = zms_ = skipSpc(zms);
  150.     for (i = 0; i < 4; i++) {
  151.         if (!stricmp2(zms, p[i])) {
  152.             flag = 0;
  153.             break;
  154.         }
  155.     }
  156.  
  157.     zms = getnum4(zms, &mode, &err, p,-1);
  158.     zms = skipSpc(zms);
  159.     if (flag && (*zms == ']' || *zms == ',')) {    /* omit the mode */
  160.         mode = 2;
  161.         zms = zms_;
  162.     } else {
  163.         if (err < 0) {
  164.             mode = 0;
  165.         } else if (err) {
  166.             zmserror("[ARCCn.LEVEL] format error.",line,linebuf,zms,0,1);
  167.         }
  168.     }
  169.  
  170.     zms = skipSpc(zms);
  171.     if (*zms == ',') {
  172.         zms++;
  173.     }
  174.     zms = makeARCClevel0(zms,trkdata,target,trkinf,no,mode);
  175.  
  176.     return zms;
  177. }
  178.  
  179.  
  180. UBYTE *makeARCClevel0(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],
  181.                         TRKINF *trkinf, int no, int mode)
  182. {
  183.     DWORD tmpDWORD;
  184.     int trk,err;
  185.     DWORD line_ = line;
  186.     UBYTE *zms_ = zms;
  187.     LINEDATA *ld_ = ld;
  188.  
  189.     for (trk = 0; target[trk] >= 0; trk++) {
  190.         int i;
  191.         VELOETCVAR v[17];
  192.         const int Trk = target[trk];
  193.  
  194.         line = line_;
  195.         ld = ld_;
  196.         zms = makeZmdEigDepthSub(zms_,v,&trkinf[Trk].arccpos,
  197.                                     &trkinf[Trk].arccnum,1);
  198.  
  199.         *trkdata[Trk].zmd++ = 0xE5;
  200.         *trkdata[Trk].zmd++ = no * 2;
  201.         if (mode == -2 && trkinf[Trk].arccnum < 2) {
  202.             if (trkinf[Trk].arccnum == 0) {            /* arcc sw off */
  203. /*OK*/
  204.                 *trkdata[Trk].zmd++ = 0x00;
  205.                 *trkdata[Trk].zmd++ = 0x00;
  206.             } else if (trkinf[Trk].arccnum == 1) {    /* arcc single */
  207. /*OK*/
  208.                 int v_ = v[0].var[0] + trkinf[Trk].arccofst[no];
  209.                 if (v_ > 127) {
  210.                     v_ = 127;
  211.                 } else if (v_ < -128) {
  212.                     v_ = -128;
  213.                 }
  214.                 *trkdata[Trk].zmd++ = 0x01;
  215.                 *trkdata[Trk].zmd++ = 0x01;
  216.                 *trkdata[Trk].zmd++ = v_;
  217.             }
  218.         } else {                                /* arcc dep1/8 */
  219. /*OK*/        UBYTE *zmd__;
  220.             UBYTE flg = 0;
  221.  
  222.             if (mode == -2) {
  223.                 mode = 0xFF;
  224.             } else if (mode == 2 && trkinf[Trk].arccnum == 1) {
  225.                 mode = 0x01;
  226.             }
  227.             *trkdata[Trk].zmd++ = mode;
  228.             zmd__ = trkdata[Trk].zmd++;
  229.  
  230.             for (i = 0; i < trkinf[Trk].arccnum; i++) {
  231.                 trkinf[Trk].arcc[i].var[0]    = v[i].var[0];
  232.                 trkinf[Trk].arcc[i].relflg[0] = v[i].relflg[0];
  233.  
  234.                 flg >>= 1;
  235.                 if (v[i].relflg[0] != 2) {
  236.                     int v_ = v[i].var[0] + trkinf[Trk].arccofst[no];
  237.                     if (v_ > 127) {
  238.                         v_ = 127;
  239.                     } else if (v_ < -128) {
  240.                         v_ = -128;
  241.                     }
  242.                     *trkdata[Trk].zmd++ = v_;
  243.                     flg |= 0x80;
  244.                 }
  245.             }
  246.             for (i = trkinf[Trk].arccnum; i < 8; i++) {
  247.                 trkinf[Trk].arcc[i].var[0]    = 0;
  248.                 trkinf[Trk].arcc[i].relflg[0] = 2;
  249.                 flg >>= 1;
  250.                 flg &= 0x7F;
  251.             }
  252.             *zmd__ = flg;
  253.         }
  254.     }
  255.  
  256.     return zms;
  257. }
  258.  
  259.  
  260.  
  261.  
  262. UBYTE *makeARCCdeepen(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no,
  263.                         TRKINF *trkinf)
  264. {
  265.     const char *p[] = {"off", "on", NULL};
  266.     DWORD mode;
  267.     int err, trk;
  268.     const BYTE parabytes[3] = { 3, 1, 3 };
  269.  
  270.     zms = getnum4(zms, &mode, &err, p, 0);
  271.     if (err < 0) {
  272.         mode = 0;
  273.     } else if (err > 0) {
  274.         zmserror("[ARCCn.DEEPEN] format error.",line,linebuf,zms,0,1);
  275.     }
  276.     if (*zms == ',') {
  277.         zms++;
  278.     }
  279.  
  280.     zms = makeZmdManyParas2A(zms,trkdata,target,line,linebuf,
  281.                             0xDB, 3, parabytes, 1, no, mode,
  282.                             "[ARCCn.DEEPEN]: too many parameters.",
  283.                             "[ARCCn.DEEPEN] can't use relational parameters.",
  284.                             "");
  285.  
  286.     return zms;
  287. }
  288.  
  289.  
  290.  
  291. UBYTE *makeARCCcontrol(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no)
  292. {
  293.     DWORD para;
  294.     int err, trk;
  295.     const char *p[] = {
  296.         "bank_msb", "vibrato", "ctrl2", "ctrl3", "ctrl4", "portament_time",
  297.         "data_entry_msb", "volume", "ctrl8", "ctrl9", "panpot", "expression",
  298.         "ctrl12", "ctrl13", "ctrl14", "ctrl15", "ctrl16", "ctrl17", "ctrl18",
  299.         "ctrl19", "ctrl20", "ctrl21", "ctrl22", "ctrl23", "ctrl24", "ctrl25",
  300.         "ctrl26", "ctrl27", "ctrl28", "ctrl29", "ctrl30", "ctrl31",
  301.         "bank_lsb", "ctrl33", "ctrl34", "ctrl35", "ctrl36", "data_entry_lsb",
  302.         "ctrl38", "ctrl39", "ctrl40", "ctrl41", "ctrl42",
  303.         "ctrl43", "ctrl44", "ctrl45", "ctrl46", "ctrl47", "ctrl48", "ctrl49",
  304.         "ctrl50", "ctrl51", "ctrl52", "ctrl53", "ctrl54", "ctrl55", "ctrl56",
  305.         "ctrl57", "ctrl58", "ctrl59", "ctrl60", "ctrl61", "ctrl62", "ctrl63",
  306.         "damper", "portament", "sostenuto", "soft", "ctrl68", "freeze",
  307.         "ctrl70", "ctrl71", "ctrl72", "ctrl73", "ctrl74", "ctrl75", "ctrl76",
  308.         "ctrl77", "ctrl78", "ctrl79", "ctrl80", "ctrl81", "ctrl82", "ctrl83",
  309.         "portament_ctrl", "ctrl85", "ctrl86", "ctrl87", "ctrl88", "ctrl89",
  310.         "ctrl90", "reverb", "tremolo", "chorus", "delay", "phaser", "data_increment",
  311.         "data_decrement", "nrpn_lsb", "nrpn_msb", "rpn_lsb", "rpn_msb", 
  312.         "ctrl102", "ctrl103", "ctrl104", "ctrl105", "ctrl106", "ctrl107",
  313.          "ctrl108", "ctrl109", "ctrl110", "ctrl111", "ctrl112", "ctrl113",
  314.          "ctrl114", "ctrl115", "ctrl116", "ctrl117", "ctrl118", "ctrl119",
  315.          "all_sound_off", "reset_all_controllers", "local", "all_notes_off",
  316.          "omni_off", "omni_on", "mono", "poly", NULL
  317.     };
  318.  
  319.     zms = getnum4(zms, ¶, &err, p, 0);
  320.  
  321.     for (trk = 0; target[trk] >= 0; trk++) {
  322.         const int Trk = target[trk];
  323.  
  324.         *trkdata[Trk].zmd++ = 0xF7;
  325.         *trkdata[Trk].zmd++ = no * 2;
  326.         *trkdata[Trk].zmd++ = 0x80;
  327.         *trkdata[Trk].zmd++ = para;
  328.     }
  329.     return zms;
  330. }
  331.  
  332.  
  333. UBYTE *makeARCCorigin(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no)
  334. {
  335.     DWORD para;
  336.     int trk;
  337.  
  338.     zms = get1AbsPara(zms,¶,0,127,
  339.                     "[ARCCn.ORIGIN]: parameter is out of range.",
  340.                     "[ARCCn.ORIGIN]: parameter can't omit.");
  341.  
  342.     for (trk = 0; target[trk] >= 0; trk++) {
  343.         const int Trk = target[trk];
  344.  
  345.         *trkdata[Trk].zmd++ = 0xF7;
  346.         *trkdata[Trk].zmd++ = no * 2;
  347.         *trkdata[Trk].zmd++ = 0x20;
  348.         *trkdata[Trk].zmd++ = para;
  349.     }
  350.     return zms;
  351. }
  352.  
  353.  
  354. UBYTE *makeARCCreset(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no)
  355. {
  356.     DWORD para;
  357.     int trk;
  358.  
  359.     zms = get1AbsPara(zms,¶,0,127,
  360.                     "[ARCCn.RESET]: parameter is out of range.",
  361.                     "[ARCCn.RESET]: parameter can't omit.");
  362.  
  363.     for (trk = 0; target[trk] >= 0; trk++) {
  364.         const int Trk = target[trk];
  365.  
  366.         *trkdata[Trk].zmd++ = 0xF7;
  367.         *trkdata[Trk].zmd++ = no * 2;
  368.         *trkdata[Trk].zmd++ = 0x40;
  369.         *trkdata[Trk].zmd++ = para;
  370.     }
  371.     return zms;
  372. }
  373.  
  374.  
  375.  
  376. UBYTE *makeARCCwaveform(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no)
  377. {
  378.     const char *p[] = {"saw", "square", "triangle", "s.saw", "random", NULL};
  379.     DWORD form;
  380.     int err, trk;
  381.  
  382.     zms = getnum4(zms, &form, &err, p, 0);
  383.     if (!err < 0) {
  384.         zmserror("[ARCCn.WAVEFORM] format error.",line,linebuf,zms,0,1);
  385.     }
  386.  
  387.     for (trk = 0; target[trk] >= 0; trk++) {
  388.         const int Trk = target[trk];
  389.  
  390.         *trkdata[Trk].zmd++ = 0xC9;
  391.         *trkdata[Trk].zmd++ = no * 2;
  392.         if (form >= 8) {
  393.             form += 0x8000 - 8;
  394.         }
  395.         putWord(trkdata[Trk].zmd, form);
  396.         trkdata[Trk].zmd += 2;
  397.     }
  398.  
  399.     return zms;
  400. }
  401.  
  402.  
  403. UBYTE *makeARCCswitch(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no)
  404. {
  405.     const char *p[] = {"1/8", "off", "optional", "on", NULL};
  406.     DWORD mode;
  407.     int err, trk;
  408.  
  409.  
  410.     zms = getnum4(zms, &mode, &err, p, -1);
  411.     if (!err < 0) {
  412.         zmserror("[ARCCn.SWITCH] format error.",line,linebuf,zms,0,1);
  413.     }
  414.  
  415.     for (trk = 0; target[trk] >= 0; trk++) {
  416.         const int Trk = target[trk];
  417.  
  418.         *trkdata[Trk].zmd++ = 0xB3;
  419.         *trkdata[Trk].zmd++ = no * 2;
  420.         *trkdata[Trk].zmd++ = mode;
  421.     }
  422.  
  423.     return zms;
  424. }
  425.  
  426.  
  427. UBYTE *makeARCCsync(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no)
  428. {
  429.     const char *p[] = {"off", "on", NULL};
  430.     DWORD mode, c = 0;
  431.     UBYTE mode2 = 0;
  432.     int i, err, trk;
  433.  
  434.  
  435.     zms = getnum4(zms, &mode, &err, p, 0);
  436.     if (!err < 0) {
  437.         zmserror("[ARCCn.SYNC] format error.",line,linebuf,zms,0,1);
  438.     }
  439.     zms = skipSpc(zms);
  440.     if (*zms == ',') {
  441.         zms = getnum2(++zms, &c, &err);
  442.         if (err < 0) {
  443.             c = 0;
  444.         } else if (c > 0) {
  445.             zmserror("[ARCCn.SYNC] format error.",line,linebuf,zms,0,1);
  446.         }
  447.     }
  448.  
  449.     for (i = 0; i < 4; i++) {
  450.         mode2 <<= 1;
  451.         if (mode & 1) {
  452.             mode2++;
  453.         }
  454.         mode >>= 1;
  455.     }
  456.     for (i = 0; i < 4; i++) {
  457.         mode2 <<= 1;
  458.     }
  459.  
  460.     for (trk = 0; target[trk] >= 0; trk++) {
  461.         const int Trk = target[trk];
  462.  
  463.         *trkdata[Trk].zmd++ = 0xB5;
  464.         *trkdata[Trk].zmd++ = no * 2;
  465.         *trkdata[Trk].zmd++ = mode2;
  466.         putWord(trkdata[Trk].zmd, c);
  467.         trkdata[Trk].zmd += 2;
  468.     }
  469.  
  470.     return zms;
  471. }
  472.  
  473.  
  474. UBYTE *makeARCCmode(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no)
  475. {
  476.     const char *p[] = {"normal", "special", "enhanced", NULL};
  477.     DWORD mode;
  478.     int err, trk;
  479.  
  480.  
  481.     zms = getnum4(zms, &mode, &err, p, 0);
  482.     if (!err < 0) {
  483.         zmserror("[ARCCn.MODE] format error.",line,linebuf,zms,0,1);
  484.     }
  485.  
  486.     if (mode == 2) {
  487.         mode = 1;
  488.     }
  489.  
  490.     for (trk = 0; target[trk] >= 0; trk++) {
  491.         const int Trk = target[trk];
  492.  
  493.         *trkdata[Trk].zmd++ = 0xB4;
  494.         *trkdata[Trk].zmd++ = no * 2;
  495.         *trkdata[Trk].zmd++ = mode - 1;
  496.     }
  497.  
  498.     return zms;
  499. }
  500.  
  501.  
  502.  
  503.  
  504. UBYTE *makeARCCphase(UBYTE *zms,TRKCHINF *trkdata, const BYTE target[],DWORD no)
  505. {
  506.     const char *p[] = {"normal", "reverse", "inverse", NULL};
  507.     DWORD mode;
  508.     int err, trk;
  509.  
  510.  
  511.     zms = getnum4(zms, &mode, &err, p, 0);
  512.     if (!err < 0) {
  513.         zmserror("[ARCCn.PHASE] format error.",line,linebuf,zms,0,1);
  514.     }
  515.     if (mode == 2) {
  516.         mode = 1;
  517.     }
  518.  
  519.     for (trk = 0; target[trk] >= 0; trk++) {
  520.         const int Trk = target[trk];
  521.  
  522.         *trkdata[Trk].zmd++ = 0xF7;
  523.         *trkdata[Trk].zmd++ = no * 2;
  524.         *trkdata[Trk].zmd++ = 0x10;
  525.         *trkdata[Trk].zmd++ = -mode;
  526.     }
  527.     return zms;
  528. }
  529.  
  530. UBYTE *makeARCCoffset(UBYTE *zms,TRKINF *trkinf, const BYTE target[],DWORD no)
  531. {
  532. /*    const char *p[] = {"on", "off", NULL};*/
  533.     DWORD mode, offset;
  534.     int err, trk;
  535.  
  536.  
  537. /*    zms = getnum4(zms, &mode, &err, p, 0);*/
  538.     zms = getnum2(zms, &offset, &err);
  539.     if (!err < 0) {
  540.         zmserror("[ARCCn.OFFSET] format error.",line,linebuf,zms,0,1);
  541.     }
  542.  
  543.     for (trk = 0; target[trk] >= 0; trk++) {
  544.         const int Trk = target[trk];
  545.  
  546.         trkinf[Trk].arccofst[no] = offset;
  547.     }
  548.     return zms;
  549. }
  550.